Durvenson's extension of the Goodstein function
(I am not aware of how fast this grows. It might be a weak extension, or it might be undefined.) In the "order two" Goodstein function, all rules are unchanged for the most part, but instead of using an exponent representation, both the Goodstein function (order 1) and exponents will be used. Here are the additional rules: 1. If \(X = G_y(X)\), then it is illegal to include \(G_y(X)\) in the sequence. 2. Both exponents and the Goodstein function will be used, although the Goodstein function will be prioritized over exponents when possible. 3. G_x(y) starts out as G^1_x(y), then when the base bump occurs, it becomes G^2_x(y). There is an "order three" Goodstein function as well, which is the same as the order two function, but it also includes the order two Goodstein function, which as you might expect, prioritizes over the order one version. The order four version is the same thing again, but it includes the order three Goldenstein function, which yet prioritizes over everything else. The notation for the Goodenstein function now is G(a,b) where a is the order and b is the "starting" number. Now, this can be a hireachy. G(w,b) uses every order of the goodenstein function before order w, where the higher orders still priortize. At this point, all finite orders will have their orders be converted as well. G(w+1,b) uses every finite number ordered goodenstein function as well as order w. G(2w,b) uses orders 0 to 2w - 1, G(w^2,b) uses all the orders before order w^2, and allows order conversion for all orders less than w^2, and so on. (By the way, after w^2, the next order that allows more orders to be converted is w^^2, then e0, and so on. In general, in order to get the next order that allows for orders to converted, you have to replace all integers in the equation with a w, then convert it into a "higher order form" (+ becomes *, * becomes ^, ^ becomes ^^, and so on). (also, do not simplify any expressions that are formed) By introducing ordinals for orders, a extra rule has to be introduced. 1. With a number like 2w or w^2, the omega part will be ignored and will not be converted, but the number part will be converted. Now, we can expand on order. We can make order of order (the value that is listed before order), which is identical to the concept of order, with the only difference being that conversion occurs within the order, recrusion and main input of the Goodstein function instead of just the input and recrusion, and bumping happens within the order and recrusion if the "order of order" is greater than 1. Also, order of order behaves similarly to order, with the bumping and conversion rules that applied to order in the 2-input case applying to order of order. Now, also, "below order" refers to either having a lesser order and having a equal "order of order", or just simply having a lesser "order of order". To recap, the array is the following: G(a,b,c) This can be easily further extended to order of order of order, which will be listed before the order of order. Now, nesting applies in order of order, order, recursion, and the main input, as you may have guessed, and conversion applies to order of order, order, recursion, and the main input. Below "order of order" now is having a lesser order of order and having a equal order of order of order, or simply just having a lesser order of order of order. This process can just be repeated forever and ever to form a narray, which is represented G(a,b,c,d,e,f...) or G(@). We can add an ordinal hireachy to this concept. Now, 0 is the main input, 1 is the order, 2 is the order of order, 3 is the order of rder of order, and so on. These will be put after the values to properly represent the positions, which also means that 1s can just be omitted regardless of position. It doesn't have to be ordered anymore. A example of this is in G(15,32,821). Ordinals can be put within the []s to make things like w, w^2, e0, etc, but the issue with this is that we need to define ordinal labels first. w is similar to 1, 2, 3, and so on. However, rather than nesting within the value, it uses nesting within the (integers) labels. w+1 is a norder above w, so it nests/converts within values labeled below w (and nesting still doesn't happen within 0). Now, the "place" in which the nesting/converts will be labedle x. w2's nesting forms ...yw+x, w3's nesting forms ...y2w+x w^2's nesting forms ...ywx, and so on. Category:RECURSIVE FUNCTIONS Category:FUNCTIONS